boe.pres.k12.wv.us/boe.pres.k12.wv.us.zip/boe.pres.k12.wv.us/Utilities/Xerox Workcentre 5335/Windows Scan/64-bit_x64/Japanese/cpsimage.cab/data/xipProcs/morphology.proc

Text File | 2009-04-23 | 9KB | 318 lines

/*
** This script is a collection of software constructs for binary and grayscale
** morphological image processing.
*/

// Structuring element values for binary morphology
#define SE_DONT_CARE  "-1";
#define SE_MISS       "0";
#define SE_HIT        "1";

// Class definition for rectangular structuring element
CLASS STREL
{
  INTEGER width;
  INTEGER height;
  ELFLIST center;
  ELFLIST data;

  METHOD toString ()
    RETURNS (STRING sestr)
  {
    INTEGER i;
    INTEGER count;

    sestr = this.width + " " + this.height;

    count = this.data.length ();
    for (i=0; i<count; i++)
       sestr = sestr +  " " + this.data[i];
  }
}

/* @XIPMakePepperStrel
  // DESCRIPTION
  Creates a rectangular structuring element for filtering pepper noise (small,
  isolated black spots) from an image. The structuring element is returned as
  the STREL object "strel".

  // ARGUMENTS
  INTEGER level       This is the pepper removal level. It represents the
                      maximum width and height of the black spots to be
                      removed. The pepper removal level can be:
                        1 to remove 1x1 spots
                        2 to remove spots that can fit inside a 2x2 square
                        3 to remove spots that can fit inside a 3x3 square
                        4 to remove spots that can fit inside a 4x4 square

  // RETURNS
  STREL   strel       Structuring element
*/
private
PROCEDURE XIPMakePepperStrel (INTEGER level)
  RETURNS (STREL strel)
{
  INTEGER s;
  INTEGER c;
  INTEGER x;
  INTEGER y;
  INTEGER innerValue;

  if (level < 1) level = 1;
  if (level > 4) level = 4;

  if (level == 1)
    innerValue = SE_HIT;
  else
    innerValue = SE_DONT_CARE;

  s = level + 2;
  c = (s - 1) / 2;

  strel.width  = s;
  strel.height = s;
  strel.center = (c, c);

  for (y=0; y<s; y++) {
    for (x=0; x<s; x++) {
      if (y < 1) {
        strel.data.insert (obj: SE_MISS);
      } else if (y < (level+1)) {
        if (x < 1) {
          strel.data.insert (obj: SE_MISS);
        } else if (x < (level+1)) {
          strel.data.insert (obj: innerValue);
        } else {
          strel.data.insert (obj: SE_MISS);
        }
      } else {
        strel.data.insert (obj: SE_MISS);
      }
    }
  }
}

/* @XIPMakeSolidStrel
  // DESCRIPTION
  Creates a rectangular structuring element containing all hits, i.e. the
  value of each member is set to SE_HIT. The structuring element is returned
  as the STREL object "strel".

  // ARGUMENTS
  INTEGER width       Width of structuring element
  INTEGER height      Height of structuring element

  // RETURNS
  STREL   strel       Structuring element
*/
private
PROCEDURE XIPMakeSolidStrel (INTEGER width, INTEGER height)
  RETURNS (STREL strel)
{
  INTEGER size;
  INTEGER cx;
  INTEGER cy;
  INTEGER idx;

  strel.width  = width;
  strel.height = height;

  cx = (width - 1) / 2;
  cy = (height - 1) / 2;
  strel.center = (cx, cy);

  size = width * height;
  for (idx=0; idx<size; idx++)
    strel.data.insert (obj: SE_HIT);
}

/* @XIPErode
  // DESCRIPTION
  Performs binary/gray morphological erosion on a given XIPIMAGE. The eroded
  image is returned as the XIPIMAGE object "dst".

  // ARGUMENTS
  XIPIMAGE src        Image to erode
  STREL    strel      Structuring element

  // OPTIONAL ARGUMENTS
  STRING   type       By specifying type as "binary", processing will route
                      through XEngine erode_ipc module (adaptation of IPCore
                      binary erosion routine that supports 1 bit grayscale
                      images only). Otherwise, it routes through XEngine
                      grayerode module (supports 8 bit grayscale images).

  // RETURNS
  XIPIMAGE dst        Eroded image
*/
private
PROCEDURE XIPErode (XIPIMAGE src, STREL strel, STRING type)
  RETURNS (XIPIMAGE dst)
{
  STRING sestr;

  // Need at least gray colorspace to process
  if (src.getMember (member: "seps") > 1)
    src = src.cspace (outspace: "gray");

  // Convert structuring element to a string
  sestr = strel.toString ();

  // Do binary erosion if type is "binary"; otherwise do gray erosion
  if (type == "binary") {
    if (src.getMember (member: "bits") > 1)
      src = src.convert (to: (1));

    dst = src.erode_ipc (sestring: sestr);
  } else {
    dst = src.invert ().grayerode (file: sestr).invert ();
  }
}

/* @XIPDilate
  // DESCRIPTION
  Performs binary/gray morphological dilation on a given XIPIMAGE. The dilated
  image is returned as the XIPIMAGE object "dst".

  // ARGUMENTS
  XIPIMAGE src        Image to dilate
  STREL    strel      Structuring element

  // OPTIONAL ARGUMENTS
  STRING   type       By specifying type as "binary", processing will route
                      through XEngine dilate_ipc module (adaptation of IPCore
                      binary dilation routine that supports 1 bit grayscale
                      images only). Otherwise, it routes through XEngine
                      graydilate module (supports 8 bit grayscale images).

  // RETURNS
  XIPIMAGE dst        Dilated image
*/
private
PROCEDURE XIPDilate (XIPIMAGE src, STREL strel, STRING type)
  RETURNS (XIPIMAGE dst)
{
  STRING sestr;

  // Need at least gray colorspace to process
  if (src.getMember (member: "seps") > 1)
    src = src.cspace (outspace: "gray");

  // Convert structuring element to a string
  sestr = strel.toString ();

  // Do binary dilation if type is "binary"; otherwise do gray dilation
  if (type == "binary") {
    if (src.getMember (member: "bits") > 1)
      src = src.convert (to: (1));

    dst = src.dilate_ipc (sestring: sestr);
  } else {
    dst = src.invert ().graydilate (file: sestr).invert ();
  }
}

/* @XIPOpen
  // DESCRIPTION
  Performs binary/gray morphological erosion followed by dilation on a given
  XIPIMAGE using the same structuring element. The opened image is returned as
  the XIPIMAGE object "dst".

  // ARGUMENTS
  XIPIMAGE src        Image to open
  STREL    strel      Structuring element

  // OPTIONAL ARGUMENTS
  STRING   type       By specifying type as "binary", processing will route
                      through XEngine erode_ipc and dilate_ipc modules
                      (adaptations of IPCore binary erosion and dilation
                      routines, respectively, that supports 1 bit grayscale
                      images only). Otherwise, it routes through XEngine
                      grayerode and graydilate modules (supports 8 bit
                      grayscale images).

  // RETURNS
  XIPIMAGE dst        Opened image
*/
private
PROCEDURE XIPOpen (XIPIMAGE src, STREL strel, STRING type)
  RETURNS (XIPIMAGE dst)
{
  STRING sestr;

  // Need at least gray colorspace to process
  if (src.getMember (member: "seps") > 1)
    src = src.cspace (outspace: "gray");

  // Convert structuring element to a string
  sestr = strel.toString ();

  // Do binary opening if type is "binary"; otherwise do gray opening
  if (type == "binary") {
    if (src.getMember (member: "bits") > 1)
      src = src.convert (to: (1));

    dst = src.erode_ipc (sestring: sestr
            ).dilate_ipc (sestring: sestr
            );
  } else {
    dst = src.invert (
            ).grayerode (file: sestr
            ).graydilate (file: sestr
            ).invert (
            );
  }
}

/* @XIPClose
  // DESCRIPTION
  Performs binary/gray morphological dilation followed by erosion on a given
  XIPIMAGE using the same structuring element. The closed image is returned as
  the XIPIMAGE object "dst".

  // ARGUMENTS
  XIPIMAGE src        Image to close
  STREL    strel      Structuring element

  // OPTIONAL ARGUMENTS
  STRING   type       By specifying type as "binary", processing will route
                      through XEngine erode_ipc and dilate_ipc modules
                      (adaptations of IPCore binary erosion and dilation
                      routines, respectively, that supports 1 bit grayscale
                      images only). Otherwise, it routes through XEngine
                      grayerode and graydilate modules (supports 8 bit
                      grayscale images).

  // RETURNS
  XIPIMAGE dst        Closed image
*/
private
PROCEDURE XIPClose (XIPIMAGE src, STREL strel, STRING type)
  RETURNS (XIPIMAGE dst)
{
  STRING sestr;

  // Need at least gray colorspace to process
  if (src.getMember (member: "seps") > 1)
    src = src.cspace (outspace: "gray");

  // Convert structuring element to a string
  sestr = strel.toString ();

  // Do binary closing if type is "binary"; otherwise do gray closing
  if (type == "binary") {
    if (src.getMember (member: "bits") > 1)
      src = src.convert (to: (1));

    dst = src.dilate_ipc (sestring: sestr
            ).erode_ipc (sestring: sestr
            );
  } else {
    dst = src.invert (
            ).graydilate (file: sestr
            ).grayerode (file: sestr
            ).invert (
            );
  }
}